/**
 * 文本格式相关工具函数
 */

/**
 * 格式元数据接口
 */
export interface FormatMetadata {
    hasBold: boolean;
    hasItalic: boolean;
    hasUnderline: boolean;
    hasMarkdown: boolean;
    hasHtml: boolean;
    lineCount: number;
    charCount: number;
}

/**
 * 提取文本中的格式元数据
 * @param text 要分析的文本
 * @returns 格式元数据
 */
export const extractFormatMetadata = (text: string): FormatMetadata => {
    if (!text) {
        return {
            hasBold: false,
            hasItalic: false,
            hasUnderline: false,
            hasMarkdown: false,
            hasHtml: false,
            lineCount: 0,
            charCount: 0
        };
    }

    // 检测Markdown格式
    const hasBold = /\*\*[^*]+\*\*|__[^_]+__/.test(text);
    const hasItalic = /(?<!\*)\*(?!\*)[^*]+\*(?!\*)|(?<!_)_(?!_)[^_]+_(?!_)/.test(text);
    const hasMarkdown = hasBold || hasItalic || /^#{1,6}\s|^\s*>|^\s*-\s|^\s*\d+\.\s|`[^`]+`|^\s*```[\s\S]*```\s*$|!\[.*\]\(.*\)|\[.*\]\(.*\)/.test(text);

    // 检测HTML格式
    const hasHtml = /<[^>]+>/.test(text);
    const hasUnderline = /<u>[\s\S]*?<\/u>/.test(text);

    // 统计行数和字符数
    const lineCount = text.split('\n').length;
    const charCount = text.replace(/\s/g, '').length;

    return {
        hasBold,
        hasItalic,
        hasUnderline,
        hasMarkdown,
        hasHtml,
        lineCount,
        charCount
    };
};

/**
 * 检测并自动选择完整段落
 * @param text 全文内容
 * @param position 当前选择位置
 * @returns 段落的起始和结束位置
 */
export const detectParagraph = (text: string, position: number): { start: number, end: number } => {
    if (!text || position < 0 || position >= text.length) {
        return { start: 0, end: 0 };
    }

    // 向前查找段落开始
    let start = position;
    while (start > 0 && text[start - 1] !== '\n') {
        start--;
    }

    // 向后查找段落结束
    let end = position;
    while (end < text.length && text[end] !== '\n') {
        end++;
    }

    return { start, end };
};

/**
 * 检测并自动选择完整节（多个段落组成的一节）
 * @param text 全文内容
 * @param position 当前选择位置
 * @returns 小节的起始和结束位置
 */
export const detectSection = (text: string, position: number): { start: number, end: number } => {
    if (!text || position < 0 || position >= text.length) {
        return { start: 0, end: 0 };
    }

    // 向前查找小节开始（标题或两个连续的换行）
    let start = position;
    let foundSectionStart = false;

    while (start > 0 && !foundSectionStart) {
        // 检查是否是标题行
        const isSectionHeader = /^#{1,3}\s/.test(text.substring(start, start + 20).split('\n')[0]);
        // 检查是否是两个连续的换行
        const isDoubleNewline = start > 1 && text[start - 1] === '\n' && text[start - 2] === '\n';

        if (isSectionHeader || isDoubleNewline) {
            foundSectionStart = true;
            if (isDoubleNewline) start++; // 调整位置，包含一个换行符
        } else {
            start--;
        }
    }

    // 向后查找小节结束（下一个标题或连续两个换行）
    let end = position;
    let foundSectionEnd = false;

    while (end < text.length && !foundSectionEnd) {
        // 检查是否遇到下一个标题
        if (text[end] === '\n' && end + 1 < text.length && text[end + 1] === '#') {
            foundSectionEnd = true;
        }
        // 检查是否遇到两个连续的换行
        else if (text[end] === '\n' && end + 1 < text.length && text[end + 1] === '\n') {
            end += 2; // 包含两个换行符
            foundSectionEnd = true;
        }
        else {
            end++;
        }
    }

    return { start, end };
}; 